JavaScript മൊഡ്യൂൾ ഡെക്കറേറ്റർ പാറ്റേണുകൾ: സ്വഭാവം മെച്ചപ്പെടുത്തൽ

JavaScript വികസനത്തിന്റെ മാറിക്കൊണ്ടിരിക്കുന്ന ലോകത്ത്, വൃത്തിയുള്ളതും, പരിപാലിക്കാവുന്നതും, വീണ്ടും ഉപയോഗിക്കാവുന്നതുമായ കോഡ് എഴുതുന്നത് വളരെ പ്രധാനമാണ്. കാതലായ ലോജിക് മാറ്റാതെ തന്നെ JavaScript മൊഡ്യൂളുകളുടെ സ്വഭാവം മെച്ചപ്പെടുത്തുന്നതിനുള്ള ശക്തമായ ഒരു സാങ്കേതികതയാണ് മൊഡ്യൂൾ ഡെക്കറേറ്റർ പാറ്റേണുകൾ വാഗ്ദാനം ചെയ്യുന്നത്. ഈ സമീപനം ആശങ്കകളുടെ വേർതിരിവ് പ്രോത്സാഹിപ്പിക്കുന്നു, ഇത് നിങ്ങളുടെ കോഡിനെ കൂടുതൽ ഫ്ലെക്സിബിളും, ടെസ്റ്റബിളും, മനസ്സിലാക്കാൻ എളുപ്പവുമാക്കുന്നു.

എന്താണ് മൊഡ്യൂൾ ഡെക്കറേറ്ററുകൾ?

ഒരു മൊഡ്യൂൾ ഡെക്കറേറ്റർ എന്നത് ഒരു മൊഡ്യൂളിനെ (സാധാരണയായി ഒരു ഫംഗ്‌ഷനോ ക്ലാസ്സോ) ഇൻപുട്ടായി എടുക്കുകയും ആ മൊഡ്യൂളിന്റെ പരിഷ്കരിച്ച പതിപ്പ് തിരികെ നൽകുകയും ചെയ്യുന്ന ഒരു ഫംഗ്‌ഷനാണ്. ഡെക്കറേറ്റർ, അതിന്റെ സോഴ്സ് കോഡ് നേരിട്ട് മാറ്റാതെ തന്നെ, ഒറിജിനൽ മൊഡ്യൂളിന്റെ സ്വഭാവം ചേർക്കുകയോ അല്ലെങ്കിൽ മാറ്റം വരുത്തുകയോ ചെയ്യുന്നു. ഇത് ഓപ്പൺ/ക്ലോസ്ഡ് തത്വത്തിന് അനുസൃതമാണ്, സോഫ്റ്റ്‌വെയർ സ്ഥാപനങ്ങൾ (ക്ലാസുകൾ, മൊഡ്യൂളുകൾ, ഫംഗ്‌ഷനുകൾ, മുതലായവ) വിപുലീകരണത്തിനായി തുറന്നിരിക്കണം, എന്നാൽ മാറ്റങ്ങൾ വരുത്തുന്നതിന് ക്ലോസ് ചെയ്യണം എന്ന് ഈ തത്വം പറയുന്നു.

ഒരു പിസ്സയിലേക്ക് അധിക ടോപ്പിംഗുകൾ ചേർക്കുന്നതുപോലെ ഇത് ചിന്തിക്കുക. ബേസ് പിസ്സ (ഒറിജിനൽ മൊഡ്യൂൾ) അതേപടി നിലനിൽക്കുന്നു, എന്നാൽ നിങ്ങൾ ഇത് അധിക ഫ്ലേവറുകളും ഫീച്ചറുകളും (ഡെക്കറേറ്ററുടെ കൂട്ടിച്ചേർക്കലുകൾ) ഉപയോഗിച്ച് മെച്ചപ്പെടുത്തിയിട്ടുണ്ട്.

മൊഡ്യൂൾ ഡെക്കറേറ്ററുകൾ ഉപയോഗിക്കുന്നതിന്റെ പ്രയോജനങ്ങൾ

• മെച്ചപ്പെട്ട കോഡ് വീണ്ടും ഉപയോഗിക്കാവുന്നവ: ഒന്നിലധികം മൊഡ്യൂളുകളിൽ ഡെക്കറേറ്ററുകൾ പ്രയോഗിക്കാൻ കഴിയും, ഇത് നിങ്ങളുടെ കോഡ്‌ബേസിൽ സ്വഭാവം മെച്ചപ്പെടുത്തുന്നത് വീണ്ടും ഉപയോഗിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു.
• മെച്ചപ്പെടുത്തിയ മെയിന്റനൻസ്: ആശങ്കകൾ വേർതിരിക്കുന്നതിലൂടെ, വ്യക്തിഗത മൊഡ്യൂളുകളും അവയുടെ മെച്ചപ്പെടുത്തലുകളും മനസ്സിലാക്കാനും, പരിഷ്കരിക്കാനും, പരീക്ഷിക്കാനും ഡെക്കറേറ്ററുകൾ എളുപ്പമാക്കുന്നു.
• വർദ്ധിച്ച ഫ്ലെക്സിബിലിറ്റി: ഒറിജിനൽ മൊഡ്യൂളിന്റെ കോഡ് മാറ്റാതെ തന്നെ ഫംഗ്‌ഷനാലിറ്റി ചേർക്കുന്നതിനും അല്ലെങ്കിൽ മാറ്റം വരുത്തുന്നതിനും ഡെക്കറേറ്ററുകൾ ഒരു ഫ്ലെക്സിബിൾ മാർഗം നൽകുന്നു.
• ഓപ്പൺ/ക്ലോസ്ഡ് തത്വത്തിന്റെ പാലിക്കൽ: നിങ്ങളുടെ സോഴ്സ് കോഡ് നേരിട്ട് മാറ്റാതെ തന്നെ മൊഡ്യൂളുകളുടെ പ്രവർത്തനം വിപുലീകരിക്കാൻ ഡെക്കറേറ്ററുകൾ നിങ്ങളെ പ്രാപ്തരാക്കുന്നു, ഇത് മെയിന്റനൻസ് പ്രോത്സാഹിപ്പിക്കുകയും ബഗുകൾ ഉണ്ടാകാനുള്ള സാധ്യത കുറയ്ക്കുകയും ചെയ്യുന്നു.
• മെച്ചപ്പെട്ട ടെസ്റ്റബിലിറ്റി: ഡെക്കറേറ്റർ ഫംഗ്‌ഷനുകൾ മോക്ക് ചെയ്യുന്നതിലൂടെയോ അല്ലെങ്കിൽ സ്റ്റബ് ചെയ്യുന്നതിലൂടെയോ ഡെക്കറേറ്റ് ചെയ്ത മൊഡ്യൂളുകൾ എളുപ്പത്തിൽ പരീക്ഷിക്കാൻ കഴിയും.

പ്രധാന ആശയങ്ങളും നടപ്പാക്കലും

അതിന്റെ കാതലിൽ, ഒരു മൊഡ്യൂൾ ഡെക്കറേറ്റർ ഒരു ഉയർന്ന-ഓർഡർ ഫംഗ്‌ഷനാണ്. ഇത് ഒരു ഫംഗ്‌ഷൻ (അല്ലെങ്കിൽ ക്ലാസ്) ഒരു ആർഗ്യുമെന്റായി എടുക്കുകയും ഒരു പുതിയതും, പരിഷ്കരിച്ചതുമായ ഫംഗ്‌ഷൻ (അല്ലെങ്കിൽ ക്ലാസ്) തിരികെ നൽകുകയും ചെയ്യുന്നു. ഒറിജിനൽ ഫംഗ്‌ഷനെ എങ്ങനെ കൈകാര്യം ചെയ്യണമെന്നും ആവശ്യമുള്ള സ്വഭാവം എങ്ങനെ ചേർക്കണമെന്നും മനസ്സിലാക്കുക എന്നതാണ് ഇതിലെ പ്രധാന കാര്യം.

അടിസ്ഥാന ഡെക്കറേറ്റർ ഉദാഹരണം (ഫംഗ്ഷൻ ഡെക്കറേറ്റർ)

ഒരു ഫംഗ്‌ഷൻ എക്സിക്യൂഷൻ സമയം ലോഗ് ചെയ്യുന്നതിന് ഡെക്കറേറ്റ് ചെയ്യുന്നതിന്റെ ലളിതമായ ഒരു ഉദാഹരണം ഇതാ:

            function timingDecorator(func) {
  return function(...args) {
    const start = performance.now();
    const result = func.apply(this, args);
    const end = performance.now();
    console.log(`Function ${func.name} took ${end - start}ms`);
    return result;
  };
}

function myExpensiveFunction(n) {
  let result = 0;
  for (let i = 0; i < n; i++) {
    result += i;
  }
  return result;
}

const decoratedFunction = timingDecorator(myExpensiveFunction);

console.log(decoratedFunction(100000));

            

              
                Copy
              
            
          

ഈ ഉദാഹരണത്തിൽ, timingDecorator എന്നത് ഡെക്കറേറ്റർ ഫംഗ്‌ഷനാണ്. ഇത് myExpensiveFunction ഇൻപുട്ടായി എടുക്കുകയും ഒറിജിനൽ ഫംഗ്‌ഷൻ ഉൾക്കൊള്ളുന്ന ഒരു പുതിയ ഫംഗ്‌ഷൻ തിരികെ നൽകുകയും ചെയ്യുന്നു. ഈ പുതിയ ഫംഗ്‌ഷൻ എക്സിക്യൂഷൻ സമയം അളക്കുകയും അത് കൺസോളിൽ ലോഗ് ചെയ്യുകയും ചെയ്യുന്നു.

ക്ലാസ് ഡെക്കറേറ്ററുകൾ (ES ഡെക്കറേറ്റേഴ്സ് നിർദ്ദേശം)

ECMAScript ഡെക്കറേറ്റേഴ്സ് നിർദ്ദേശം (നിലവിൽ സ്റ്റേജ് 3-ൽ) ക്ലാസുകളും ക്ലാസ് അംഗങ്ങളും ഡെക്കറേറ്റ് ചെയ്യുന്നതിന് കൂടുതൽ മികച്ച ഒരു സിന്റാക്സ് അവതരിപ്പിക്കുന്നു. എല്ലാ JavaScript എൻവയോൺമെന്റുകളിലും ഇത് ഇതുവരെ പൂർണ്ണമായി സ്റ്റാൻഡേർഡ് ചെയ്തിട്ടില്ലെങ്കിലും, ഇത് പ്രചാരം നേടുകയാണ്, കൂടാതെ Babel, TypeScript തുടങ്ങിയ ടൂളുകൾ ഇതിനെ പിന്തുണക്കുന്നു.

ഒരു ക്ലാസ് ഡെക്കറേറ്ററിൻ്റെ ഒരു ഉദാഹരണം ഇതാ:

            // Requires a transpiler like Babel with the decorators plugin

function LogClass(constructor) {
  return class extends constructor {
    constructor(...args) {
      super(...args);
      console.log(`Creating a new instance of ${constructor.name}`);
    }
  };
}

@LogClass
class MyClass {
  constructor(name) {
    this.name = name;
  }
  greet() {
    console.log(`Hello, ${this.name}!`);
  }
}

const instance = new MyClass("Alice");
instance.greet();

            

              
                Copy
              
            
          

ഈ സാഹചര്യത്തിൽ, @LogClass എന്നത് MyClass-ൽ പ്രയോഗിക്കുമ്പോൾ, ക്ലാസിന്റെ ഒരു പുതിയ ഇൻസ്റ്റൻസ് ഉണ്ടാകുമ്പോഴെല്ലാം ഒരു സന്ദേശം ലോഗ് ചെയ്യുന്നതിന് അതിന്റെ കൺസ്ട്രക്റ്റർ മെച്ചപ്പെടുത്തുന്ന ഒരു ഡെക്കറേറ്ററാണ്.

മെത്തേഡ് ഡെക്കറേറ്ററുകൾ (ES ഡെക്കറേറ്റേഴ്സ് നിർദ്ദേശം)

നിങ്ങൾക്ക് ഒരു ക്ലാസിനുള്ളിലെ വ്യക്തിഗത രീതികളും ഡെക്കറേറ്റ് ചെയ്യാവുന്നതാണ്:

            // Requires a transpiler like Babel with the decorators plugin

function LogMethod(target, propertyKey, descriptor) {
  const originalMethod = descriptor.value;

  descriptor.value = function(...args) {
    console.log(`Calling method ${propertyKey} with arguments: ${args}`);
    const result = originalMethod.apply(this, args);
    console.log(`Method ${propertyKey} returned: ${result}`);
    return result;
  };
  return descriptor;
}

class MyClass {
  constructor(name) {
    this.name = name;
  }

  @LogMethod
  add(a, b) {
    return a + b;
  }
}

const instance = new MyClass("Bob");
instance.add(5, 3);

            

              
                Copy
              
            
          

ഇവിടെ, @LogMethod എന്നത് add രീതിയെ ഡെക്കറേറ്റ് ചെയ്യുന്നു, രീതിയിലേക്ക് കൈമാറിയ ആർഗ്യുമെന്റുകളും അത് നൽകുന്ന മൂല്യവും ലോഗ് ചെയ്യുന്നു.

സാധാരണ മൊഡ്യൂൾ ഡെക്കറേറ്റർ പാറ്റേണുകൾ

വിവിധ ഡിസൈൻ പാറ്റേണുകൾ നടപ്പിലാക്കാനും നിങ്ങളുടെ മൊഡ്യൂളുകളിലേക്ക് ക്രോസ്-കട്ടിംഗ് ആശങ്കകൾ ചേർക്കാനും മൊഡ്യൂൾ ഡെക്കറേറ്ററുകൾ ഉപയോഗിക്കാൻ കഴിയും. ചില പൊതുവായ ഉദാഹരണങ്ങൾ ഇതാ:

1. ലോഗിംഗ് ഡെക്കറേറ്റർ

മുമ്പത്തെ ഉദാഹരണങ്ങളിൽ കാണിച്ചതുപോലെ, ലോഗിംഗ് ഡെക്കറേറ്ററുകൾ മൊഡ്യൂളുകളിലേക്ക് ലോഗിംഗ് പ്രവർത്തനം ചേർക്കുന്നു, ഇത് അവയുടെ സ്വഭാവത്തെയും പ്രകടനത്തെയും കുറിച്ചുള്ള ഉൾക്കാഴ്ച നൽകുന്നു. ആപ്ലിക്കേഷനുകൾ ഡീബഗ്ഗ് ചെയ്യാനും നിരീക്ഷിക്കാനും ഇത് വളരെ ഉപയോഗപ്രദമാണ്.

ഉദാഹരണം: ഒരു ലോഗിംഗ് ഡെക്കറേറ്റർക്ക് ഫംഗ്‌ഷൻ കോളുകൾ, ആർഗ്യുമെന്റുകൾ, റിട്ടേൺ മൂല്യങ്ങൾ, എക്സിക്യൂഷൻ സമയം എന്നിവ ഒരു കേന്ദ്ര ലോഗിംഗ് സേവനത്തിലേക്ക് ലോഗ് ചെയ്യാൻ കഴിയും. ഒന്നിലധികം സേവനങ്ങളിലുടനീളം അഭ്യർത്ഥനകൾ ട്രാക്കുചെയ്യേണ്ട വിതരണം ചെയ്ത സിസ്റ്റങ്ങളിലും അല്ലെങ്കിൽ മൈക്രോ service ആർക്കിടെക്ചറുകളിലും ഇത് പ്രത്യേകിച്ചും മൂല്യവത്താണ്.

2. കാഷിംഗ് ഡെക്കറേറ്റർ

ചെലവേറിയ ഫംഗ്‌ഷൻ കോളുകളുടെ ഫലങ്ങൾ കാഷിംഗ് ഡെക്കറേറ്ററുകൾ കാഷെ ചെയ്യുന്നു, ഇത് ഒരേ മൂല്യങ്ങൾ വീണ്ടും കണക്കുകൂട്ടേണ്ടതിന്റെ ആവശ്യകത കുറയ്ക്കുന്നതിലൂടെ പ്രകടനം മെച്ചപ്പെടുത്തുന്നു.

            function cacheDecorator(func) {
  const cache = new Map();

  return function(...args) {
    const key = JSON.stringify(args);
    if (cache.has(key)) {
      console.log("Fetching from cache");
      return cache.get(key);
    }

    const result = func.apply(this, args);
    cache.set(key, result);
    return result;
  };
}

function expensiveCalculation(n) {
  console.log("Performing expensive calculation");
  // Simulate a time-consuming operation
  let result = 0;
  for (let i = 0; i < n; i++) {
    result += Math.sqrt(i);
  }
  return result;
}

const cachedCalculation = cacheDecorator(expensiveCalculation);

console.log(cachedCalculation(1000));
console.log(cachedCalculation(1000)); // Fetches from cache

            

              
                Copy
              
            
          

അന്താരാഷ്ട്രവൽക്കരണ ഉദാഹരണം: കറൻസി എക്സ്ചേഞ്ച് നിരക്കുകൾ പ്രദർശിപ്പിക്കേണ്ട ഒരു ആപ്ലിക്കേഷൻ പരിഗണിക്കുക. കാഷിംഗ് ഡെക്കറേറ്ററിന് കറൻസി കൺവേർഷൻ സേവനത്തിലേക്കുള്ള API കോളുകളുടെ ഫലങ്ങൾ സംഭരിക്കാൻ കഴിയും, ഇത് ഉണ്ടാക്കുന്ന അഭ്യർത്ഥനകളുടെ എണ്ണം കുറയ്ക്കുകയും, കുറഞ്ഞ ഇന്റർനെറ്റ് കണക്ഷനുള്ള അല്ലെങ്കിൽ ഉയർന്ന ലേറ്റൻസി ഉള്ള പ്രദേശങ്ങളിലെ ഉപയോക്താക്കൾക്കായി ഉപയോക്തൃ അനുഭവം മെച്ചപ്പെടുത്തുകയും ചെയ്യുന്നു.

3. പ്രാമാണീകരണ ഡെക്കറേറ്റർ

ഉപയോക്തൃ പ്രാമാണീകരണ നിലയെ ആശ്രയിച്ച് ചില മൊഡ്യൂളുകളിലേക്കും ഫംഗ്‌ഷനുകളിലേക്കും ആക്‌സസ് നിയന്ത്രിക്കുന്നത് പ്രാമാണീകരണ ഡെക്കറേറ്ററുകളാണ്. ഇത് നിങ്ങളുടെ ആപ്ലിക്കേഷൻ സുരക്ഷിതമാക്കാനും അനധികൃത ആക്‌സസ് തടയാനും സഹായിക്കുന്നു.

            function authenticationDecorator(func) {
  return function(...args) {
    if (isAuthenticated()) { // Replace with your authentication logic
      return func.apply(this, args);
    } else {
      console.log("Authentication required");
      return null; // Or throw an error
    }
  };
}

function isAuthenticated() {
  // Replace with your actual authentication check
  return true; // For demonstration purposes
}

function sensitiveOperation() {
  console.log("Performing sensitive operation");
}

const authenticatedOperation = authenticationDecorator(sensitiveOperation);

authenticatedOperation();

            

              
                Copy
              
            
          

ഗ്ലോബൽ കോൺടെക്സ്റ്റ്: ഒരു ലോകளாவ്യാപകമായ ഇ-കൊമേഴ്‌സ് പ്ലാറ്റ്‌ഫോമിൽ, അംഗീകൃത ജീവനക്കാർക്ക് മാത്രം ഓർഡർ മാനേജ്‌മെൻ്റ് ഫംഗ്‌ഷനുകളിലേക്ക് പ്രവേശനം നിയന്ത്രിക്കാൻ ഒരു പ്രാമാണീകരണ ഡെക്കറേറ്റർ ഉപയോഗിക്കാം. isAuthenticated() ഫംഗ്‌ഷൻ പ്ലാറ്റ്‌ഫോമിന്റെ സുരക്ഷാ മാതൃകയെ അടിസ്ഥാനമാക്കി ഉപയോക്താവിൻ്റെ റോളുകളും അനുമതികളും പരിശോധിക്കേണ്ടതുണ്ട്, ഇത് പ്രാദേശിക നിയന്ത്രണങ്ങളെ ആശ്രയിച്ച് വ്യത്യാസപ്പെടാം.

4. സാധൂകരണ ഡെക്കറേറ്റർ

എക്സിക്യൂഷനുമുമ്പ് ഒരു ഫംഗ്‌ഷന്റെ ഇൻപുട്ട് പാരാമീറ്ററുകൾ സാധൂകരിക്കുന്നത് സാധൂകരണ ഡെക്കറേറ്ററുകളാണ്, ഇത് ഡാറ്റയുടെ സമഗ്രത ഉറപ്പാക്കുകയും പിശകുകൾ തടയുകയും ചെയ്യുന്നു.

            function validationDecorator(validator) {
  return function(func) {
    return function(...args) {
      const validationResult = validator(args);
      if (validationResult.isValid) {
        return func.apply(this, args);
      } else {
        console.error("Validation failed:", validationResult.errorMessage);
        throw new Error(validationResult.errorMessage);
      }
    };
  };
}

function createUserValidator(args) {
  const [username, email] = args;
  if (!username) {
    return { isValid: false, errorMessage: "Username is required" };
  }
  if (!email.includes("@")) {
    return { isValid: false, errorMessage: "Invalid email format" };
  }
  return { isValid: true };
}

function createUser(username, email) {
  console.log(`Creating user with username: ${username} and email: ${email}`);
}

const validatedCreateUser = validationDecorator(createUserValidator)(createUser);

validatedCreateUser("john.doe", "john.doe@example.com");
validatedCreateUser("jane", "invalid-email");

            

              
                Copy
              
            
          

സ്ഥാനവൽക്കരണവും സാധൂകരണവും: ഒരു ആഗോള വിലാസ ഫോമിൽ, ഉപയോക്താവിൻ്റെ രാജ്യത്തെ അടിസ്ഥാനമാക്കി പോസ്റ്റൽ കോഡുകൾ സാധൂകരിക്കുന്നതിന് ഒരു സാധൂകരണ ഡെക്കറേറ്റർ ഉപയോഗിക്കാം. validator ഫംഗ്‌ഷൻ രാജ്യ-നിർദ്ദിഷ്ട മൂല്യനിർണ്ണയ നിയമങ്ങൾ ഉപയോഗിക്കേണ്ടതുണ്ട്, ഒരു ബാഹ്യ API-യിൽ നിന്നോ കോൺഫിഗറേഷൻ ഫയലിൽ നിന്നോ ഇത് കൊണ്ടുവരാവുന്നതാണ്. ഇത് ഓരോ പ്രദേശത്തിന്റെയും പോസ്റ്റൽ ആവശ്യകതകൾക്കനുസരിച്ച് വിലാസ ഡാറ്റ സ്ഥിരതയുള്ളതാണെന്ന് ഉറപ്പാക്കുന്നു.

5. വീണ്ടും ശ്രമിക്കുക (Retry) ഡെക്കറേറ്റർ

നിങ്ങളുടെ ആപ്ലിക്കേഷന്റെ പ്രതിരോധശേഷി മെച്ചപ്പെടുത്തുന്നതിനായി, പ്രത്യേകിച്ചും വിശ്വാസ്യമല്ലാത്ത സേവനങ്ങളോ അല്ലെങ്കിൽ നെറ്റ്‌വർക്ക് കണക്ഷനുകളോ കൈകാര്യം ചെയ്യുമ്പോൾ, ഒരു ഫംഗ്‌ഷൻ കോൾ പരാജയപ്പെട്ടാൽ വീണ്ടും ശ്രമിക്കുന്നത് Retry ഡെക്കറേറ്ററുകളാണ്.

            function retryDecorator(maxRetries) {
  return function(func) {
    return async function(...args) {
      let retries = 0;
      while (retries < maxRetries) {
        try {
          const result = await func.apply(this, args);
          return result;
        } catch (error) {
          console.error(`Attempt ${retries + 1} failed:`, error);
          retries++;
          await new Promise(resolve => setTimeout(resolve, 1000)); // Wait 1 second before retrying
        }
      }
      throw new Error(`Function failed after ${maxRetries} retries`);
    };
  };
}

async function fetchData() {
  // Simulate a function that might fail
  if (Math.random() < 0.5) {
    throw new Error("Failed to fetch data");
  }
  return "Data fetched successfully!";
}

const retryFetchData = retryDecorator(3)(fetchData);

retryFetchData()
  .then(data => console.log(data))
  .catch(error => console.error("Final error:", error));

            

              
                Copy
              
            
          

നെറ്റ്‌വർക്ക് പ്രതിരോധശേഷി: സ്ഥിരതയില്ലാത്ത ഇന്റർനെറ്റ് കണക്ഷനുകളുള്ള പ്രദേശങ്ങളിൽ, ഓർഡറുകൾ സമർപ്പിക്കുകയോ അല്ലെങ്കിൽ ഡാറ്റ സംരക്ഷിക്കുകയോ ചെയ്യുന്നത് പോലുള്ള നിർണായക പ്രവർത്തനങ്ങൾ വിജയകരമായി പൂർത്തിയാക്കാൻ ഒരു വീണ്ടും ശ്രമിക്കുക (retry) ഡെക്കറേറ്റർ വളരെ വിലപ്പെട്ടതാണ്. വീണ്ടും ശ്രമിക്കേണ്ട എണ്ണവും, വീണ്ടും ശ്രമിക്കുന്നതിന് എടുക്കുന്ന കാലതാമസവും നിർദ്ദിഷ്ട പരിസ്ഥിതിയെയും പ്രവർത്തനത്തിന്റെ സെൻസിറ്റിവിറ്റിയെയും ആശ്രയിച്ച് കോൺഫിഗർ ചെയ്യാവുന്നതാണ്.

വിപുലമായ ടെക്നിക്കുകൾ

ഡെക്കറേറ്ററുകൾ സംയോജിപ്പിക്കുന്നു

ഒരൊറ്റ മൊഡ്യൂളിലേക്ക് ഒന്നിലധികം മെച്ചപ്പെടുത്തലുകൾ പ്രയോഗിക്കുന്നതിന് ഡെക്കറേറ്ററുകൾ സംയോജിപ്പിക്കാൻ കഴിയും. ഒറിജിനൽ മൊഡ്യൂളിന്റെ കോഡ് പരിഷ്കരിക്കാതെ തന്നെ സങ്കീർണ്ണവും വളരെ ഇഷ്ടമുള്ളതുമായ സ്വഭാവം സൃഷ്ടിക്കാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു.

            //Requires transpilation (Babel/Typescript)
function ReadOnly(target, name, descriptor) {
    descriptor.writable = false;
    return descriptor;
}

function Trace(target, name, descriptor) {
    const original = descriptor.value;
    descriptor.value = function (...args) {
        console.log(`TRACE: Calling ${name} with arguments: ${args}`);
        const result = original.apply(this, args);
        console.log(`TRACE: ${name} returned: ${result}`);
        return result;
    };
    return descriptor;
}

class Calculator {
    constructor(value) {
        this.value = value;
    }

    @Trace
    add(amount) {
        this.value += amount;
        return this.value;
    }

    @ReadOnly
    @Trace
    getValue() {
        return this.value;
    }
}

const calc = new Calculator(10);
calc.add(5); // Output will include TRACE messages
console.log(calc.getValue()); // Output will include TRACE messages

try{
    calc.getValue = function(){ return "hacked!"; }
} catch(e){
    console.log("Cannot overwrite ReadOnly property");
}

            

              
                Copy
              
            
          

ഡെക്കറേറ്റർ ഫാക്ടറികൾ

ഒരു ഡെക്കറേറ്റർ നൽകുന്ന ഒരു ഫംഗ്‌ഷനാണ് ഒരു ഡെക്കറേറ്റർ ഫാക്ടറി. ഇത് നിങ്ങളുടെ ഡെക്കറേറ്ററുകൾക്ക് പാരാമീറ്ററുകൾ നൽകാനും നിർദ്ദിഷ്ട ആവശ്യകതകളെ അടിസ്ഥാനമാക്കി അവയുടെ സ്വഭാവം കോൺഫിഗർ ചെയ്യാനും അനുവദിക്കുന്നു.

            function retryDecoratorFactory(maxRetries, delay) {
  return function(func) {
    return async function(...args) {
      let retries = 0;
      while (retries < maxRetries) {
        try {
          const result = await func.apply(this, args);
          return result;
        } catch (error) {
          console.error(`Attempt ${retries + 1} failed:`, error);
          retries++;
          await new Promise(resolve => setTimeout(resolve, delay));
        }
      }
      throw new Error(`Function failed after ${maxRetries} retries`);
    };
  };
}

// Use the factory to create a retry decorator with specific parameters
const retryFetchData = retryDecoratorFactory(5, 2000)(fetchData);

            

              
                Copy
              
            
          

പരിഗണനകളും മികച്ച രീതികളും

• ES ഡെക്കറേറ്റേഴ്സ് നിർദ്ദേശം മനസ്സിലാക്കുക: നിങ്ങൾ ES ഡെക്കറേറ്റേഴ്സ് നിർദ്ദേശം ഉപയോഗിക്കുകയാണെങ്കിൽ, സിന്റാക്സും അർത്ഥവും പരിചിതമാക്കുക. ഇത് ഇപ്പോഴും ഒരു നിർദ്ദേശമാണെന്നും ഭാവിയിൽ ഇതിന് മാറ്റങ്ങൾ വരാമെന്നും ഓർക്കുക.
• ട്രാൻസ്പൈലറുകൾ ഉപയോഗിക്കുക: നിങ്ങൾ ES ഡെക്കറേറ്റേഴ്സ് നിർദ്ദേശം ഉപയോഗിക്കുകയാണെങ്കിൽ, നിങ്ങളുടെ കോഡിനെ ബ്രൗസർ-അനുയോജ്യമായ ഫോർമാറ്റിലേക്ക് മാറ്റാൻ Babel അല്ലെങ്കിൽ TypeScript പോലുള്ള ഒരു ട്രാൻസ്പൈലർ ആവശ്യമാണ്.
• അമിതമായി ഉപയോഗിക്കുന്നത് ഒഴിവാക്കുക: ഡെക്കറേറ്ററുകൾ ശക്തമാണെങ്കിലും, അവ അമിതമായി ഉപയോഗിക്കുന്നത് ഒഴിവാക്കുക. കൂടുതൽ ഡെക്കറേറ്ററുകൾ നിങ്ങളുടെ കോഡ് മനസ്സിലാക്കാനും ഡീബഗ്ഗ് ചെയ്യാനും ബുദ്ധിമുട്ടാക്കും.
• ഡെക്കറേറ്ററുകൾ ശ്രദ്ധയോടെ ഉപയോഗിക്കുക: ഓരോ ഡെക്കറേറ്ററിനും നന്നായി നിർവചിക്കപ്പെട്ട ഒരൊറ്റ ഉദ്ദേശ്യം ഉണ്ടായിരിക്കണം. ഇത് അവയെ മനസ്സിലാക്കാനും വീണ്ടും ഉപയോഗിക്കാനും എളുപ്പമാക്കുന്നു.
• നിങ്ങളുടെ ഡെക്കറേറ്ററുകൾ പരീക്ഷിക്കുക: നിങ്ങളുടെ ഡെക്കറേറ്ററുകൾ പ്രതീക്ഷിച്ചതുപോലെ പ്രവർത്തിക്കുന്നുണ്ടെന്നും ബഗുകൾ ഉണ്ടാക്കുന്നില്ലെന്നും ഉറപ്പാക്കാൻ നന്നായി പരീക്ഷിക്കുക.
• നിങ്ങളുടെ ഡെക്കറേറ്ററുകൾ രേഖപ്പെടുത്തുക: നിങ്ങളുടെ ഡെക്കറേറ്ററുകൾ വ്യക്തമായി രേഖപ്പെടുത്തുക, അവയുടെ ഉദ്ദേശ്യം, ഉപയോഗം, സാധ്യമായ ഏതെങ്കിലും പാർശ്വഫലങ്ങൾ എന്നിവ വിശദീകരിക്കുക.
• പ്രകടനം പരിഗണിക്കുക: ഡെക്കറേറ്ററുകൾ നിങ്ങളുടെ കോഡിലേക്ക് അധിക ചിലവ് ചേർക്കാൻ സാധ്യതയുണ്ട്. പ്രകടനാത്മകമായ കാര്യങ്ങൾ ശ്രദ്ധിക്കുക, പ്രത്യേകിച്ചും പതിവായി വിളിക്കുന്ന ഫംഗ്ഷനുകൾ ഡെക്കറേറ്റ് ചെയ്യുമ്പോൾ. ആവശ്യമുള്ളിടത്ത് കാഷിംഗ് ടെക്നിക്കുകൾ ഉപയോഗിക്കുക.

യഥാർത്ഥ ലോക ഉദാഹരണങ്ങൾ

തുടങ്ങിയ നിരവധി യഥാർത്ഥ ലോക സാഹചര്യങ്ങളിൽ മൊഡ്യൂൾ ഡെക്കറേറ്ററുകൾ പ്രയോഗിക്കാൻ കഴിയും:

• ഫ്രെയിംവർക്കുകളും ലൈബ്രറികളും: ആധുനിക JavaScript ഫ്രെയിംവർക്കുകളും ലൈബ്രറികളും ഡിപ്പൻഡൻസി ഇൻജക്ഷൻ, റൂട്ടിംഗ്, സ്റ്റേറ്റ് മാനേജ്മെൻ്റ് തുടങ്ങിയ ഫീച്ചറുകൾ നൽകുന്നതിന് ഡെക്കറേറ്ററുകൾ വ്യാപകമായി ഉപയോഗിക്കുന്നു. ഉദാഹരണത്തിന്, Angular, ഡെക്കറേറ്ററുകളെ വളരെയധികം ആശ്രയിക്കുന്നു.
• API ക്ലയിന്റുകൾ: API ക്ലയിന്റ് ഫംഗ്‌ഷനുകളിൽ ലോഗിംഗ്, കാഷിംഗ്, പ്രാമാണീകരണം എന്നിവ ചേർക്കാൻ ഡെക്കറേറ്ററുകൾ ഉപയോഗിക്കാം.
• ഡാറ്റ മൂല്യനിർണ്ണയം: ഒരു ഡാറ്റാബേസിലേക്ക് സംരക്ഷിക്കുന്നതിനോ അല്ലെങ്കിൽ ഒരു API-യിലേക്ക് അയക്കുന്നതിനോ മുമ്പ് ഡാറ്റ സാധൂകരിക്കുന്നതിന് ഡെക്കറേറ്ററുകൾ ഉപയോഗിക്കാം.
• ഇവന്റ് കൈകാര്യം ചെയ്യൽ: ഇവന്റ് കൈകാര്യം ചെയ്യൽ യുക്തി ലളിതമാക്കാൻ ഡെക്കറേറ്ററുകൾ ഉപയോഗിക്കാം.

ഉപസംഹാരം

JavaScript മൊഡ്യൂൾ ഡെക്കറേറ്റർ പാറ്റേണുകൾ നിങ്ങളുടെ കോഡിന്റെ സ്വഭാവം മെച്ചപ്പെടുത്തുന്നതിനും, വീണ്ടും ഉപയോഗിക്കാവുന്നതും, പരിപാലിക്കാവുന്നതും, ടെസ്റ്റ് ചെയ്യാവുന്നതുമാക്കുന്നതിനും ശക്തവും ഫ്ലെക്സിബിളുമായ ഒരു മാർഗ്ഗം വാഗ്ദാനം ചെയ്യുന്നു. ഈ ലേഖനത്തിൽ ചർച്ച ചെയ്ത പ്രധാന ആശയങ്ങൾ മനസ്സിലാക്കുന്നതിലൂടെയും പാറ്റേണുകൾ പ്രയോഗിക്കുന്നതിലൂടെയും നിങ്ങൾക്ക് കൂടുതൽ വൃത്തിയുള്ളതും, ശക്തവും, സ്കേലബിളുമായ JavaScript ആപ്ലിക്കേഷനുകൾ എഴുതാൻ കഴിയും. ES ഡെക്കറേറ്റേഴ്സ് നിർദ്ദേശത്തിന് കൂടുതൽ സ്വീകാര്യത ലഭിക്കുന്നതിനനുസരിച്ച്, ഈ സാങ്കേതികവിദ്യ ആധുനിക JavaScript വികസനത്തിൽ കൂടുതൽ പ്രചാരത്തിലാകും. നിങ്ങളുടെ പ്രോജക്റ്റുകളുടെ പ്രത്യേക ആവശ്യങ്ങൾക്കനുസരിച്ച് നിങ്ങളുടെ സ്വന്തം ഇഷ്ടമുള്ള ഡെക്കറേറ്ററുകൾ പര്യവേക്ഷണം ചെയ്യുക, പരീക്ഷിക്കുക, കൂടാതെ നിങ്ങളുടെ പ്രോജക്റ്റുകളിൽ ഈ പാറ്റേണുകൾ ഉൾപ്പെടുത്തുക.